package cn.lyjuan.dwz_manage.core.java.service;


import cn.lyjuan.dwz_manage.core.base.pojo.ActionPojo;
import cn.lyjuan.dwz_manage.core.base.pojo.ManagePojo;
import cn.lyjuan.dwz_manage.core.base.pojo.RolePojo;
import cn.lyjuan.dwz_manage.core.java.dto.QueryResultBean;
import cn.lyjuan.dwz_manage.core.java.exception.DwzManageException;
import cn.lyjuan.dwz_manage.core.java.mapper.IMgPrivilegeMapper;
import cn.lyjuan.dwz_manage.core.java.mapper.IMgRoleMapper;
import cn.lyjuan.dwz_manage.core.java.util.SuperAdminUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PostAuthorize;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.*;

/**
 * Created by ly on 2015/1/16.
 */
@Service("mgRoleService")
public class RoleService
{
    private static Logger log = LogManager.getLogger(RoleService.class.getName());

    @Autowired
    private IMgRoleMapper roleMapper;

    @Autowired
    private IMgPrivilegeMapper privilegeMapper;

    /**
     * 查询管理员创建的角色
     * @param roleid
     * @return
     */
    @PostAuthorize("returnObject.createby == principal.username")// 角色创建者
    public RolePojo queryRoleForManage(int roleid)
    {
        // TODO 权限设计有问题
        return roleMapper.selectById(roleid);
    }

    /**
     * 查询所有角色
     * 如果是超级管理员可以查看所有角色<br />
     * 普通用户只能 (1.查看自己创建的角色（如果有创建角色权限的话）和 (2.自己所属的角色（被用户的创建者分配的角色）<br />
     * @return
     */
    public QueryResultBean<RolePojo> queryRolesForManage(ManagePojo manage, Map<String, String> param, int pn, int ps)
    {
        QueryResultBean<RolePojo> bean       = new QueryResultBean<RolePojo>();
        int                       totleCount = 0;
        List<RolePojo>            list       = null;

        if (SuperAdminUtils.isSuperManager(manage.getCreateby()))// 超级管理员能查看所有角色
        {
            totleCount = roleMapper.selectAllRoleCount(param);
            list = roleMapper.selectAllRoles(param, (pn - 1) * ps, ps);
        }
        else // 非超级管理员只能查看自己创建的角色和自己所属的角色
        {
            totleCount = roleMapper.selectRoleCountForManage(manage.getId(), param);
            list = roleMapper.selectRolesForManage(manage.getId(), param, (pn - 1) * ps, ps);
        }

        bean.setTotalCount(totleCount);
        bean.setList(list);
        return bean;
    }

    /**
     * 管理员创建角色
     * @param manager
     * @param role
     * @return
     */
    public RolePojo addRole(ManagePojo manager, RolePojo role)
    {
        // 判断角色名称是否存在
        int nameExist = roleMapper.selectRoleCountByName(role.getName());
        if (nameExist > 0)
            throw new DwzManageException("角色名称已存在");

        // 创建
        role.setCreatetime(new Date());
        role.setCreateby(manager.getName());
        roleMapper.insert(role);

        return role;
    }

    /**
     * 更新角色信息
     * @param fromRole
     * @param toRole
     * @return
     */
    @PreAuthorize("#fromRole.createby == principal.username")// 角色创建者
    public RolePojo saveRole(RolePojo fromRole, RolePojo toRole)
    {
        if (StringUtils.isEmpty(toRole.getName()))
            throw new IllegalArgumentException("角色名称不能为空");

        if (fromRole.getName().equals(toRole.getName()))
            return fromRole;

        int nameExist = roleMapper.selectRoleCountByName(toRole.getName());
        if (nameExist > 0)
            throw new DwzManageException("角色名称已存在");

        fromRole.setName(toRole.getName());
        roleMapper.updateRoleName(fromRole.getId(), fromRole.getName());

        return fromRole;
    }

    /**
     * 查询用户关联的角色
     * @param manage
     * @return
     */
    public List<RolePojo> queryRelatedRole(ManagePojo manage)
    {
        return roleMapper.selectRolesRelated(manage.getId());
    }

    public void relateAction(ManagePojo manage, List<ActionPojo> hadActions, RolePojo role, Integer[] actionIds)
    {
        if (null == hadActions || hadActions.isEmpty())
            throw new DwzManageException("当前无任何请求权限");

        // 判断所有请求是否均有权限操作
        if (null != actionIds)
        {
            // 去重
            Set<Integer> set = new HashSet<>(actionIds.length);
            set.addAll(Arrays.asList(actionIds));
            actionIds = set.toArray(new Integer[set.size()]);

            // 判断是否所有角色都有权限操作
            boolean hasAction;
            for (Integer d : actionIds)
            {
                if (null == d || d < 1)
                    throw new DwzManageException("请求参数不合法");
                hasAction = false;// 初始化控制
                for (ActionPojo r : hadActions)
                {
                    if (d == r.getId())
                    {
                        hasAction = true;
                        break;
                    }
                }
                if (!hasAction)// 角色无权限操作
                {
                    log.info("[{}] 无权限操作 [{}]请求", manage.getName(), d);
                    throw new DwzManageException("无权限");
                }
            }
        }

        // 删除取消的
        int delCount = privilegeMapper.deleteNotInAction(role.getId(), actionIds);

        // 添加未关联的
        if (null != actionIds && actionIds.length > 0)
        {
            int addCount = privilegeMapper.insertNotExistActions(manage.getName(), role.getId(), actionIds);
        }
    }
}
